package com.solution.admin.product.service.impl;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.solution.admin.product.constants.ProductConstants.ProductPriceFieleName;
import com.solution.admin.product.dao.ProductCategoryDao;
import com.solution.admin.product.dao.ProductDao;
import com.solution.admin.product.dao.ProductPriceDao;
import com.solution.admin.product.dao.ProductPriceHistoryDao;
import com.solution.admin.product.dao.ProductPriceLogDao;
import com.solution.admin.product.dao.ProductPropertyRelaDao;
import com.solution.admin.product.dao.ProductRecommendDao;
import com.solution.admin.product.dao.ProductSpecCompositionDao;
import com.solution.admin.product.dao.ProductSpecRelaDao;
import com.solution.admin.product.entity.ProductCategoryEntity;
import com.solution.admin.product.entity.ProductEntity;
import com.solution.admin.product.entity.ProductPriceEntity;
import com.solution.admin.product.entity.ProductPriceHistoryEntity;
import com.solution.admin.product.entity.ProductPriceLogEntity;
import com.solution.admin.product.entity.ProductPropertyRelaEntity;
import com.solution.admin.product.entity.ProductRecommendEntity;
import com.solution.admin.product.entity.ProductSpecCompositionEntity;
import com.solution.admin.product.entity.ProductSpecRelaEntity;
import com.solution.admin.product.service.ProductService;
import com.solution.common.config.PublicConfig;
import com.solution.common.constants.PublicStatus.IS_DELETE;
import com.solution.common.constants.PublicStatus.STATUS;
import com.solution.common.constants.PublicStatus.SysSymbol;
import com.solution.common.dao.BaseDao;
import com.solution.common.page.PageBean;
import com.solution.common.page.PageParam;
import com.solution.common.service.impl.BaseServiceImpl;
import com.solution.common.utils.string.StringUtil;

/**
 * 商品信息service实现层
 * 
 * @author xu_cc
 * @date 2017-08-29 20:09:14
 */
@Service
public class ProductServiceImpl extends BaseServiceImpl<ProductEntity> implements ProductService {

	/**
	 * 商品信息接口
	 */
	@Autowired
	private ProductDao productDao;

	@Autowired
	ProductPropertyRelaDao productPropertyRelaDao;

	@Autowired
	ProductCategoryDao productCategoryDao;

	@Autowired
	ProductPriceDao productPriceDao;

	@Autowired
	ProductPriceLogDao productPriceLogDao;

	@Autowired
	ProductSpecRelaDao productSpecRelaDao;

	@Autowired
	ProductSpecCompositionDao productSpecCompositionDao;

	@Autowired
	ProductRecommendDao productRecommendDao;

	@Autowired
	ProductPriceHistoryDao productPriceHistoryDao;

	@Autowired
	private com.solution.common.redis.RedisCacheClient redisCacheClient;

	protected BaseDao<ProductEntity> getDao() {
		return this.productDao;
	}

	/**
	 * 单表获取商品列表<br>
	 * 上架状态、符合品牌或者品类条件的<br>
	 * type[brand,category]<br>
	 * brandCode<br>
	 * childBrandCode<br>
	 * category<br>
	 * 
	 * @param pageParam
	 *            分页对象
	 * @param product
	 *            分页参数
	 * @return PageBean 分页参数及数据
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	public PageBean listProductForPromotionPage(PageParam pageParam, Map<String, Object> param) {
		return productDao.listProductForPromotionPage(pageParam, param);
	}

	/**
	 * 获取关联商品<br/>
	 * 
	 * @param productId
	 *            :当前商品ID<br/>
	 * @param type
	 *            :为空（已选择商品列表），不为空（未关联商品列表）<br/>
	 * @return List<ProductEntity>
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2017年9月17日 下午3:22:55
	 */
	public List<ProductEntity> listProductRela(Long productId, String type, String productCode, String productName, String productCategoryId) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("productId", productId);
		map.put("type", type);
		map.put("productCode", productCode);
		map.put("productName", productName);
		map.put("productCategoryId", productCategoryId);
		return productDao.listProductRela(map);
	}

	/**
	 * 根据productId获取选择规格信息
	 * 
	 * @param productId
	 * @return
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2017年9月16日 下午4:08:18
	 */
	public List<ProductSpecRelaEntity> listProductSpecRelaList(Long productId) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("productId", productId);
		return productSpecRelaDao.listProductSpecRela(map);
	}

	/**
	 * 获取所有价格级别数据
	 * 
	 * @Title: getProductPriceList
	 * @Description:(描述)
	 * @param productId
	 * @return List<ProductPriceEntity>
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2017年9月3日 下午1:33:04
	 */
	@Cacheable(value = "product", key = "'PRODUCT_PRICE_'+#productId")
	public List<ProductPriceEntity> getProductPriceList(Long productId) {
		return productPriceDao.listProductPrice(productId);
	}

	/**
	 * 保存商品信息
	 * 
	 * @param productEntity
	 *            商品信息实体
	 * @return Long 添加成功商品信息的ID
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #productEntity.id"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #productEntity.id") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public long saveProduct(ProductEntity productEntity) {
		productDao.saveProduct(productEntity);
		Long productCategoryId = productEntity.getProductCategoryId();
		Long zero = new Long(0);
		while (!zero.equals(productCategoryId)) {
			productCategoryDao.updateCount(productCategoryId, "add");
			// 上级
			ProductCategoryEntity category = productCategoryDao.getById(productCategoryId);
			productCategoryId = category.getParentCategoryId();
			if (zero.equals(productCategoryId)) {
				break;
			}
		}
		// 保存商品属性值
		doSaveProductProperty(productEntity.getId(), Integer.valueOf(productEntity.getPropertyTmeplateId()), productEntity.getProperties(),
		        productEntity.getCreater());
		// productPropertyRelaDao.deleteById(productEntity.getId());
		// ProductPropertyRelaEntity ppRela = null;
		// // ,1#处理器#1,2#普通硬盘#1,3#内存#1,4#显卡#1,5#系统#1
		// // TODO
		// String[] proArr =
		// productEntity.getProperties().split(SysSymbol.COMMA);
		// for (int i = 0; i < proArr.length; i++) {
		// if (StringUtil.isNotNull(proArr[i]) &&
		// proArr[i].contains(SysSymbol.NUMBER_SIGN)) {
		// String[] valArr = proArr[i].split(SysSymbol.NUMBER_SIGN);
		// ppRela = new ProductPropertyRelaEntity();
		// ppRela.setPropertyName(valArr[1]);
		// ppRela.setPropertyValue(valArr[2]);
		// ppRela.setProductId(Integer.parseInt(String.valueOf(productEntity.getId())));
		// ppRela.setCreater(productEntity.getCreater());
		// ppRela.setPropertyTmeplateId(Integer.valueOf(productEntity.getPropertyTmeplateId()));
		// ppRela.setIsDelete(IS_DELETE.NORMAL.getId());
		// ppRela.setStatus(STATUS.ENABLED.getId());
		// productPropertyRelaDao.saveProductPropertyRela(ppRela);
		// }
		// }
		return productEntity.getId();
	}

	/**
	 * 分页查询商品信息
	 * 
	 * @param pageParam
	 *            分页参数
	 * @param paramMap
	 *            查询参数
	 * @return PageBean 分页参数和分页数据
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Override
	public PageBean listProductPage(PageParam pageParam, Map<String, Object> paramMap) {
		return productDao.listProductPage(pageParam, paramMap);
	}

	/**
	 * pc端商品搜索
	 * 
	 * @param pageParam
	 * @param param
	 * @return
	 * @author lilp
	 */
	public PageBean listProductPageForIndex(PageParam pageParam, Map<String, Object> param) {
		PageBean pageBean = productDao.listProductPageForIndex(pageParam, param);
		List<ProductEntity> productList = (List) pageBean.getRecordList();
		// 查询商品列表后，再次查询商品默认规格下的价格
		initProductDefaultSpecPrice(productList);
		
		
		
		return pageBean;
	}

	/**
	 * 查询商品列表后，再次查询商品默认规格下的价格
	 * 
	 * @param productList
	 * @author lilp
	 */
	@Override
	public void initProductDefaultSpecPrice(List<ProductEntity> productList) {
		// 查询商品的规格价格，商品基价+级别差价+默认第一个规格的价格
		if (productList != null && productList.size() > 0) {
			List<Long> productCodeList = new ArrayList<Long>();
			if (productList != null && productList.size() > 0) {
				for (ProductEntity product : productList) {
					productCodeList.add(product.getId());
				}
			}
			Map<Long, Map<String, List<ProductSpecRelaEntity>>> specMap = new HashMap<Long, Map<String, List<ProductSpecRelaEntity>>>();
			if (productCodeList.size() > 0) {
				List<ProductSpecRelaEntity> specList = productSpecRelaDao.listProductSpecRelaForIndex(productCodeList);
				if (specList != null && specList.size() > 0) {
					for (ProductSpecRelaEntity productSpec : specList) {
						if (StringUtil.isNotEmpty(productSpec.getProductSpecListStr())) {
							List<ProductSpecRelaEntity> specLists = JSONArray.parseArray("[" + productSpec.getProductSpecListStr() + "]",
							        ProductSpecRelaEntity.class);
							if (specMap.containsKey(new Long(productSpec.getProductId()))) {
								Map<String, List<ProductSpecRelaEntity>> tmpMap = specMap.get(new Long(productSpec.getProductId()));
								tmpMap.put(productSpec.getSpecName(), specLists);
							} else {
								Map<String, List<ProductSpecRelaEntity>> tmpMap = new HashMap<String, List<ProductSpecRelaEntity>>();
								tmpMap.put(productSpec.getSpecName(), specLists);
								specMap.put(new Long(productSpec.getProductId()), tmpMap);
							}
						}
					}
				}
			}
			if (specMap.size() > 0 && productList.size() > 0) {
				for (ProductEntity product : productList) {
					if (specMap.containsKey(product.getId())) {
						Map<String, List<ProductSpecRelaEntity>> tmpMap = specMap.get(product.getId());
						if (tmpMap != null && tmpMap.size() > 0) {
							BigDecimal defaultSpecPrice = new BigDecimal(0);
							for (Map.Entry<String, List<ProductSpecRelaEntity>> entry : tmpMap.entrySet()) {
								List<ProductSpecRelaEntity> tmpSpecList = entry.getValue();
								defaultSpecPrice = defaultSpecPrice.add(tmpSpecList.get(0).getSpecPrice());
							}
							product.setDefaultSpecPrice(defaultSpecPrice);
							product.setMainProductPrice(product.getBasePrice());
							product.setProductPrice(product.getBasePrice().add(product.getDefaultSpecPrice() == null ? new BigDecimal(0) : product.getDefaultSpecPrice()));
						}
					} else {
						product.setDefaultSpecPrice(new BigDecimal(0));
						product.setMainProductPrice(product.getBasePrice());
						product.setProductPrice(product.getBasePrice());
					}
				}
			}
			
			// 没有规格的商品，初始化相关价格字段
			for (ProductEntity product : productList) {
				if(product.getDefaultSpecPrice() == null){
					product.setDefaultSpecPrice(new BigDecimal(0));
				}
				if(product.getMainProductPrice() == null){
					product.setMainProductPrice(product.getBasePrice());
				}
				if(product.getProductPrice() == null){
					product.setProductPrice(product.getBasePrice());
				}
			}
			
		}
	}

	/**
	 * 根据ID查询商品信息
	 * 
	 * @param id
	 *            商品id
	 * @return productEntity 商品对象
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Cacheable(value = "product", key = "'PRODUCT_'+#id")
	public ProductEntity getProductById(Long id) {
		ProductEntity product = productDao.getById(id.longValue());
		// 将图文描述中的oss访问路径转换下，以防以后换域名而导致文件不能用
		if(StringUtil.isNotNull(product.getProductIntro())) {
			String productIntro = product.getProductIntro().replaceAll("TEMPPATH", PublicConfig.IMG_ROOT_URL);
			product.setProductIntro(productIntro);
		}
		return product;
	}

	/**
	 * 从 json 对象中获取 BigDecimal
	 * 
	 * @param jsonObj
	 * @param key
	 * @return
	 * @return BigDecimal
	 * @throws Exception
	 *             exception
	 * @author xu_cc
	 * @Date 创建时间：2017年7月14日 下午6:02:05
	 */
	private BigDecimal getBigDecimalFromJson(JSONObject jsonObj, String key) {
		return BigDecimal.valueOf(jsonObj.getDouble(key));
	}

	/**
	 * 更新商品信息-基本信息
	 * 
	 * @param ProductEntity
	 *            商品信息对象
	 * @return int 更新是否成功，>1代表更新成功
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #productEntity.id"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #productEntity.id") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public int updateProductBase(ProductEntity productEntity) {
		// 分类有没有改变
		// 获取久的商品对象
		ProductEntity oldProduct = productDao.getById(productEntity.getId());
		Long oldCategoryId = oldProduct.getProductCategoryId();
		Long newCategoryId = productEntity.getProductCategoryId();
		// 不相等的情况下
		if (!oldCategoryId.equals(newCategoryId)) {
			// 新的加
			Long zero = new Long(0);
			while (!zero.equals(newCategoryId)) {
				productCategoryDao.updateCount(newCategoryId, "add");
				// 上级
				ProductCategoryEntity category = productCategoryDao.getById(newCategoryId);
				newCategoryId = category.getParentCategoryId();
				if (zero.equals(newCategoryId)) {
					break;
				}
			}
			// 旧的减
			while (!zero.equals(oldCategoryId)) {
				productCategoryDao.updateCount(oldCategoryId, "minus");
				// 上级
				ProductCategoryEntity category = productCategoryDao.getById(oldCategoryId);
				oldCategoryId = category.getParentCategoryId();
				if (zero.equals(oldCategoryId)) {
					break;
				}
			}
		}
		productDao.updateProduct(productEntity);
		doSaveProductProperty(productEntity.getId(), Integer.valueOf(productEntity.getPropertyTmeplateId()), productEntity.getProperties(),
		        productEntity.getModifier());
		// // 更新商品属性配置
		// if (StringUtil.isNotNull(productEntity.getProperties())) {
		// productPropertyRelaDao.deleteById(productEntity.getId());
		// ProductPropertyRelaEntity ppRela = null;
		// StringBuffer productProperty = new StringBuffer();
		// // ,1#处理器#1,2#普通硬盘#1,3#内存#1,4#显卡#1,5#系统#1
		// String[] proArr =
		// productEntity.getProperties().split(SysSymbol.COMMA);
		// for (int i = 0; i < proArr.length; i++) {
		// if (StringUtil.isNotNull(proArr[i]) &&
		// proArr[i].contains(SysSymbol.NUMBER_SIGN)) {
		// String[] valArr = proArr[i].split(SysSymbol.NUMBER_SIGN);
		// ppRela = new ProductPropertyRelaEntity();
		// ppRela.setPropertyName(valArr[1]);
		// ppRela.setPropertyValue(valArr[2]);
		//
		// // 拼接筛选值（eb_product_property_filter）（属性名称:属性值,）
		// productProperty.append(valArr[1]).append(SysSymbol.COLON).append(valArr[2]).append(SysSymbol.COMMA);
		// ppRela.setProductId(Integer.parseInt(String.valueOf(productEntity.getId())));
		// ppRela.setCreater(productEntity.getCreater());
		// ppRela.setPropertyTmeplateId(Integer.valueOf(productEntity.getPropertyTmeplateId()));
		// ppRela.setIsDelete(IS_DELETE.NORMAL.getId());
		// ppRela.setStatus(STATUS.ENABLED.getId());
		// productPropertyRelaDao.saveProductPropertyRela(ppRela);
		// }
		// }
		// // 保存筛选值（eb_product_property_filter）
		// if (StringUtil.isNotNull(productProperty.toString())) {
		// Map<String, Object> param = new HashMap<String, Object>();
		// param.put("productId", productEntity.getId());
		// param.put("productProperty", productProperty.toString());
		// productDao.saveProductProperty(param);
		// }
		// }
		return 1;
	}

	/**
	 * 保存属性
	 * 
	 * @param productId
	 * @param propertyTemptateId
	 * @param properties
	 * @param creater
	 *            void
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2017年11月15日 下午5:07:20
	 */
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #productId"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #productId") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void doSaveProductProperty(Long productId, Integer propertyTemptateId, String properties, String creater) {
		// 更新商品属性配置
		if (StringUtil.isNotNull(properties)) {
			productPropertyRelaDao.deleteById(productId);
			ProductPropertyRelaEntity ppRela = null;
			StringBuffer productProperty = new StringBuffer();
			// ,1#处理器#1,2#普通硬盘#1,3#内存#1,4#显卡#1,5#系统#1
			String[] proArr = properties.split(SysSymbol.COMMA);
			for (int i = 0; i < proArr.length; i++) {
				if (StringUtil.isNotNull(proArr[i]) && proArr[i].contains(SysSymbol.NUMBER_SIGN)) {
					String[] valArr = proArr[i].split(SysSymbol.NUMBER_SIGN);
					ppRela = new ProductPropertyRelaEntity();
					ppRela.setPropertyName(valArr[1]);
					ppRela.setPropertyValue(valArr[2]);

					// 拼接筛选值（eb_product_property_filter）（属性名称:属性值,）
					productProperty.append(valArr[1]).append(SysSymbol.COLON).append(valArr[2]).append(SysSymbol.COMMA);
					ppRela.setProductId(Integer.parseInt(String.valueOf(productId)));
					ppRela.setCreater(creater);
					ppRela.setPropertyTmeplateId(propertyTemptateId);
					ppRela.setIsDelete(IS_DELETE.NORMAL.getId());
					ppRela.setStatus(STATUS.ENABLED.getId());
					productPropertyRelaDao.saveProductPropertyRela(ppRela);
				}
			}
			// 保存筛选值（eb_product_property_filter）
			if (StringUtil.isNotNull(productProperty.toString())) {
				Map<String, Object> param = new HashMap<String, Object>();
				param.put("productId", productId);
				param.put("productProperty", productProperty.toString());
				productDao.saveProductProperty(param);
			}
		} else {
			// 保存模板属性值，主要是模板
			productPropertyRelaDao.deleteById(productId);
			ProductPropertyRelaEntity ppRela = new ProductPropertyRelaEntity();
			ppRela.setPropertyName(null);
			ppRela.setPropertyValue(null);
			ppRela.setProductId(Integer.parseInt(String.valueOf(productId)));
			ppRela.setCreater(creater);
			ppRela.setPropertyTmeplateId(propertyTemptateId);
			ppRela.setIsDelete(IS_DELETE.NORMAL.getId());
			ppRela.setStatus(STATUS.ENABLED.getId());
			productPropertyRelaDao.saveProductPropertyRela(ppRela);
			// 清空商品关联的属性值
			Map<String, Object> param = new HashMap<String, Object>();
			param.put("productId", productId);
			param.put("productProperty", null);
			productDao.saveProductProperty(param);
			
		}
	}

	/**
	 * 更新商品
	 * 
	 * @param productEntity
	 *            商品实体
	 * @return Long 更新是否成功，>1代表更新成功
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Override
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #productEntity.id"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #productEntity.id") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public int updateProduct(ProductEntity productEntity) {
		int result = 0;
		// 将图文描述中的oss访问路径转换下，以防以后换域名而导致文件不能用
		if(StringUtil.isNotNull(productEntity.getProductIntro())) {
			String productIntro = productEntity.getProductIntro().replaceAll(PublicConfig.IMG_ROOT_URL, "TEMPPATH");
			productEntity.setProductIntro(productIntro);
		}
		result = productDao.updateProduct(productEntity);
		// 更新关联商品
		if (null != productEntity.getProductRelaList() && productEntity.getProductRelaList().size() > 0) {
			// 删除关联商品
			productRecommendDao.deleteByProductId(productEntity.getId());
			for (ProductRecommendEntity productRela : productEntity.getProductRelaList()) {
				productRecommendDao.saveProductRecommend(productRela);
			}
		}
		// 更新商品属性配置
		if (StringUtil.isNotNull(productEntity.getProperties())) {
			productPropertyRelaDao.deleteById(productEntity.getId());
			ProductPropertyRelaEntity ppRela = null;
			// ,1#处理器#1,2#普通硬盘#1,3#内存#1,4#显卡#1,5#系统#1
			String[] proArr = productEntity.getProperties().split(SysSymbol.COMMA);
			for (int i = 0; i < proArr.length; i++) {
				if (StringUtil.isNotNull(proArr[i]) && proArr[i].contains(SysSymbol.NUMBER_SIGN)) {
					String[] valArr = proArr[i].split(SysSymbol.NUMBER_SIGN);
					ppRela = new ProductPropertyRelaEntity();
					ppRela.setPropertyName(valArr[1]);
					ppRela.setPropertyValue(valArr[2]);
					ppRela.setProductId(Integer.parseInt(String.valueOf(productEntity.getId())));
					ppRela.setCreater(productEntity.getCreater());
					ppRela.setPropertyTmeplateId(Integer.valueOf(productEntity.getPropertyTmeplateId()));
					ppRela.setIsDelete(IS_DELETE.NORMAL.getId());
					ppRela.setStatus(STATUS.ENABLED.getId());
					productPropertyRelaDao.saveProductPropertyRela(ppRela);
				}
			}
		}
		return result;
	}
	
	
	/**
	 * 更新商品排序值
	 * @param product
	 * @return
	 */
	public int updateProductSortNo(ProductEntity product){
		return productDao.updateProductSortNo(product);
	}

	/**
	 * 根据条件查询商品信息
	 * 
	 * @param param
	 * @return 数据列表
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Override
	public List<ProductEntity> listProduct(Map<String, Object> param) {
		return productDao.listProduct(param);
	}

	/**
	 * 删除商品信息
	 * 
	 * @param
	 * @return int 返回删除记录条数
	 * @author xu_cc
	 * @date 2017-08-29 20:09:14
	 */
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #id"),
	        @CacheEvict(value = "product", key = "'product_price_' + #id") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public int deleteProductById(long id) {
		// 分类有没有改变
		// 获取久的商品对象
		ProductEntity oldProduct = productDao.getById(id);
		Long oldCategoryId = oldProduct.getProductCategoryId();
		Long zero = new Long(0);
		// 旧的减
		while (!zero.equals(oldCategoryId)) {
			productCategoryDao.updateCount(oldCategoryId, "minus");
			// 上级
			ProductCategoryEntity category = productCategoryDao.getById(oldCategoryId);
			oldCategoryId = category.getParentCategoryId();
			if (zero.equals(oldCategoryId)) {
				break;
			}
		}
		return productDao.deleteById(id);
	}

	/**
	 * 保存规格设置
	 * 
	 * @param productId
	 * @param productSpecRelaList
	 * @param productSpecCompositionList
	 * @return
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2017年9月16日 下午3:28:12
	 */
	@Override
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #productId"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #productId") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public int saveProductSpecComposition(Long productId, List<ProductSpecRelaEntity> productSpecRelaList,
	        List<ProductSpecCompositionEntity> productSpecCompositionList) {
		// 删除原信息
		productSpecRelaDao.deleteProductSpecRelaById(productId);
		// 保存商品选中规格
		for (ProductSpecRelaEntity psr : productSpecRelaList) {
			productSpecRelaDao.saveProductSpecRela(psr);
		}
		productSpecCompositionDao.deleteById(productId);
		// 保存规格组合
		for (ProductSpecCompositionEntity psc : productSpecCompositionList) {
			productSpecCompositionDao.saveProductSpecComposition(psc);
		}
		return 1;
	}

	/**
	 * 更新商品
	 * 
	 * @param productEntity
	 *            商品实体
	 * @return Long 更新是否成功，>1代表更新成功
	 * @author xu_cc
	 * @throws Exception 
	 * @date 2017-08-29 20:09:14
	 */
	@Override
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #productEntity.id"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #productEntity.id") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public int updateProductPrice(ProductEntity productEntity) throws Exception {
		// 当前基价
		BigDecimal basePrice = productEntity.getBasePrice();
		// 获取原对象
		ProductEntity oldProuct = productDao.getById(productEntity.getId());
		// 价格已改变（基价） 结果是:-1 小于,0 等于,1 大于
		if (null != oldProuct.getBasePrice() && oldProuct.getBasePrice().compareTo(productEntity.getBasePrice()) != 0) {
			ProductPriceLogEntity proPriceLog = new ProductPriceLogEntity();
			proPriceLog.setProductId(productEntity.getId());
			proPriceLog.setFieldName(ProductPriceFieleName.BASE_PRICE);
			proPriceLog.setModifier(productEntity.getModifier());
			proPriceLog.setOldValue(String.valueOf(oldProuct.getBasePrice()));
			proPriceLog.setNewValue(String.valueOf(productEntity.getBasePrice()));
			productPriceLogDao.saveProductPriceLog(proPriceLog);
		}
		// 价格已改变（模拟成本）结果是:-1 小于,0 等于,1 大于
		if (null != oldProuct.getSimulationPrice() && oldProuct.getSimulationPrice().compareTo(productEntity.getSimulationPrice()) != 0) {
			ProductPriceLogEntity proPriceLog = new ProductPriceLogEntity();
			proPriceLog.setProductId(productEntity.getId());
			proPriceLog.setFieldName(ProductPriceFieleName.LOG_FIELD_NAME);
			proPriceLog.setModifier(productEntity.getModifier());
			proPriceLog.setOldValue(String.valueOf(oldProuct.getSimulationPrice()));
			proPriceLog.setNewValue(String.valueOf(productEntity.getSimulationPrice()));
			productPriceLogDao.saveProductPriceLog(proPriceLog);
		}
		productDao.updateProduct(productEntity);
		productPriceDao.deleteProductPriceById(productEntity.getId());
		ProductPriceEntity proPrice = null;
		ProductPriceHistoryEntity priceHistory = null;
		JSONArray array = JSONArray.parseArray(productEntity.getProperties());
		JSONObject jsonObj = null;
		BigDecimal diffPrice = null;
		String priceLevel = null;
		for (int j = 0; j < array.size(); j++) {
			jsonObj = array.getJSONObject(j);
			proPrice = new ProductPriceEntity();
			proPrice.setProductId(productEntity.getId());
			proPrice.setCreater(productEntity.getModifier());
			diffPrice = getBigDecimalFromJson(jsonObj, "diffPrice");
			/*if(diffPrice.compareTo(productEntity.getBasePrice()) == 1) {
				//结果是:-1 小于,0 等于,1 大于
				throw new Exception("级别差异价格不可大于基价！");
			}*/
			priceLevel = jsonObj.getString("priceLevel");
			proPrice.setDiffPrice(diffPrice);
			proPrice.setPriceLevel(priceLevel);
			productPriceDao.saveProductPrice(proPrice);
			// 价格历史
			priceHistory = new ProductPriceHistoryEntity(productEntity.getId(), basePrice, diffPrice, priceLevel, productEntity.getModifier());
			productPriceHistoryDao.saveProductPriceHistory(priceHistory);
		}
		return 1;
	}

	/**
	 * 更新商品价格（用于导入）
	 * 
	 * @param product
	 * @param proPriceList
	 * @return int
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2017年9月27日 上午12:48:37
	 */
	@Caching(evict = { @CacheEvict(value = "product", key = "'PRODUCT_' + #modMapList[0]['product'].id"),
	        @CacheEvict(value = "product", key = "'PRODUCT_PRICE_' + #modMapList[0]['product'].id") })
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public int updateProductPrice(List<Map<String, ProductEntity>> modMapList) {
		Long productId = null;
		BigDecimal basePrice = null;
		for (Map<String, ProductEntity> modMap : modMapList) {
			ProductEntity oldProduct = modMap.get("product");
			ProductEntity newProduct = modMap.get("newProduct");
			productId = newProduct.getId();
			basePrice = newProduct.getBasePrice();
			// 价格修改日志(模拟成本)
			if (null != oldProduct.getSimulationPrice() && oldProduct.getSimulationPrice().compareTo(newProduct.getSimulationPrice()) != 0) {
				ProductPriceLogEntity proPriceLog = new ProductPriceLogEntity();
				proPriceLog.setProductId(productId);
				proPriceLog.setFieldName(ProductPriceFieleName.LOG_FIELD_NAME);
				proPriceLog.setModifier(newProduct.getModifier());
				proPriceLog.setOldValue(String.valueOf(oldProduct.getSimulationPrice()));
				proPriceLog.setNewValue(String.valueOf(newProduct.getSimulationPrice()));
				productPriceLogDao.saveProductPriceLog(proPriceLog);
			}
			// 价格已改变（基价）
			if (null != oldProduct.getBasePrice() && oldProduct.getBasePrice().compareTo(newProduct.getBasePrice()) != 0) {
				ProductPriceLogEntity proPriceLog = new ProductPriceLogEntity();
				proPriceLog.setProductId(productId);
				proPriceLog.setFieldName(ProductPriceFieleName.BASE_PRICE);
				proPriceLog.setModifier(newProduct.getModifier());
				proPriceLog.setOldValue(String.valueOf(oldProduct.getBasePrice()));
				proPriceLog.setNewValue(String.valueOf(newProduct.getBasePrice()));
				productPriceLogDao.saveProductPriceLog(proPriceLog);
			}
			productDao.updateProduct(newProduct);
			productPriceDao.deleteProductPriceById(productId);
			ProductPriceHistoryEntity priceHistory = null;
			for (ProductPriceEntity proPrice : newProduct.getProductPriceList()) {
				productPriceDao.saveProductPrice(proPrice);
				// 价格历史
				priceHistory = new ProductPriceHistoryEntity(productId, basePrice, proPrice.getDiffPrice(), proPrice.getPriceLevel(),
				        proPrice.getModifier());
				productPriceHistoryDao.saveProductPriceHistory(priceHistory);
			}
			try {
				// 清除所有商品/价格缓存
				// redisCacheClient.evictBatchKeys("PRODUCT_PRICE_");
				// redisCacheClient.evictBatchKeys("PRODUCT_");
				// 删除单个商品/价格缓存
				redisCacheClient.evictOneKey("PRODUCT_PRICE_" + productId);
				redisCacheClient.evictOneKey("PRODUCT_" + productId);
			} catch (Exception e) {
				e.printStackTrace();
				continue;
			}
		}
		return 1;
	}

	/**
	 * 为首页配置楼层查询商品信息
	 * 
	 * @param param
	 * @return
	 * @author llp
	 * @date 2017-08-29 20:09:14
	 */
	public List<ProductEntity> listProductForIndex(Map<String, Object> param) {
		return productDao.listProductForIndex(param);
	}

	/**
	 * 查询商品规格项及对应价格
	 * 
	 * @param param
	 * @return
	 * @author llp
	 */
	public List<ProductSpecRelaEntity> listProductSpecPriceByProductId(Map<String, Object> param) {
		return productDao.listProductSpecPriceByProductId(param);
	}

	/**
	 * 查询商品规格项组合
	 * 
	 * @param param
	 * @return
	 * @author llp
	 */
	public List<ProductSpecCompositionEntity> listProductSpecCompostionByProductId(Map<String, Object> param) {
		return productDao.listProductSpecCompostionByProductId(param);
	}

	/**
	 * 查询首页楼层商品的价格
	 * 
	 * @param param
	 * @return
	 */
	public List<ProductEntity> listFoorProductPrice(Map<String, Object> param) {
		List<ProductEntity> productList = productDao.listFoorProductPrice(param);
		initProductDefaultSpecPrice(productList);
		return productList;
	}

	/**
	 * 通过存储过程复制商品
	 * 
	 * @param productId
	 * @param productCode
	 * @return
	 * @author xkl
	 * @date 2017年12月20日 下午3:06:20
	 */
	@Override
	public Long copyProduct(Long productId, String productCode) {
		Map<String, Object> paramMap = new HashMap<String, Object>();
		paramMap.put("productId", productId);
		paramMap.put("productCode", productCode);
		return productDao.copyProduct(paramMap);
	}

	/**
	 * 查询商品单位 、类型名称 ，用于展示页面合同商品清单
	 * 
	 * @param params
	 * @return
	 * @author lilp
	 */
	@Override
	public List<ProductEntity> listProductForContract(Map<String, Object> params) {
		return productDao.listProductForContract(params);
	}

	/**
	 * 查询推荐商品
	 * 
	 * @param productId
	 * @return
	 * @author lilp
	 */
	public List<ProductEntity> listProductRelaList(Map<String, Object> params) {
		List<ProductEntity> productList = productDao.listProductRelaList(params);
		// 初始化商品默认规格价格
		initProductDefaultSpecPrice(productList);
		return productList;
	}

	/**
	 * 查询模块配置的商品
	 * @param param
	 * @return
	 * @author xkl
	 * @date 2018年1月13日 下午4:37:11
	 */
	@Override
	public List<ProductEntity> listProductForSiteItem(Map<String, Object> param) {
		List<ProductEntity> productList = productDao.listProductForSiteItem(param);
		// 查询商品列表后，再次查询商品默认规格下的价格
		initProductDefaultSpecPrice(productList);
		return productList;
	}
	
	/**
	 * 查询pc端首页楼层的商品列表
	 * 过滤下架、删除的商品
	 * @param param
	 * @return
	 * @author lilp
	 * @date 2018年1月13日 下午4:26:17
	 */
	public List<ProductEntity> listIndexFloorProduct(Map<String, Object> param){
		return productDao.listIndexFloorProduct(param);
	}
	
	/**
	 * 查询用户收藏商品
	 * @param param
	 * @return
	 * @author xkl
	 * @date 2018年1月23日 下午7:02:47
	 */
	public List<ProductEntity> listUserFavoriteProduct(Map<String, Object> param){
		List<ProductEntity> productList = productDao.listUserFavoriteProduct(param);
		// 查询商品列表后，再次查询商品默认规格下的价格
		initProductDefaultSpecPrice(productList);
		return productList;
	}

	/**
	 * 根据商品编码获取商品
	 * @param productCode
	 * @return
	 * @author xkl
	 * @date 2018年1月26日 上午10:38:22
	 */
	@Override
	public ProductEntity getProductByCode(String productCode) {
		return productDao.getProductByCode(productCode);
	}

	/**
	 * 查询用户浏览记录商品
	 * @param param
	 * @return
	 * @author xkl
	 * @date 2018年2月1日 下午8:14:08
	 */
	@Override
	public List<ProductEntity> listProductBrowseRecord(Map<String, Object> param) {
		return productDao.listProductBrowseRecord(param);
	}
	
	/**
	 * 计算出整个订单商品的默认普通运费多少 ，快递物流运费多少，其它运费多少
	 * @param shoppingcartIds
	 * @return
	 */
	public ProductEntity listShoppingcartProductDelivery(Map<String, Object> param){
		return productDao.listShoppingcartProductDelivery(param);
	}
	
	/**
	 * 根据商品ID和商品ID批量获取商品基价
	 * @param paramMap
	 * @return
	 * @author: solin
	 * @date: 2018年4月23日 下午6:59:42
	 */
	public List<ProductEntity> listProductBasePrice(Map<String, Object> paramMap) {
		return productDao.listProductBasePrice(paramMap);
	}

	/**
	 * 根据id集合获取商品列表
	 * @param productList
	 * @return
	 * @author xkl
	 * @date 2018年6月12日 下午6:15:18
	 */
	@Override
	public Map<Long, ProductEntity> listProductMapByIds(List<String> productList) {
		return productDao.listProductMapByIds(productList);
	}
}
